package com.ts.main.admin.service;

import cn.hutool.core.collection.CollectionUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.github.pagehelper.Page;
import com.github.pagehelper.PageHelper;
import com.ts.main.admin.dto.ProductVariantSearchPageDto;
import com.ts.main.admin.entity.ProductVariantEntity;
import com.ts.main.admin.exception.CommonException;
import com.ts.main.admin.exception.RPage;
import com.ts.main.admin.mapper.ProductVariantMapper;
import com.ts.main.admin.vo.*;
import lombok.AllArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;

/**
 * @author lk
 */
@AllArgsConstructor
@Service
public class ProductVariantServiceImpl extends ServiceImpl<ProductVariantMapper, ProductVariantEntity> {

    private final ProductServiceImpl productService;

    private final ProductOptionServiceImpl productOptionService;


    public RPage<List<ProductVariantVo>> getProductVariantPage(ProductVariantSearchPageDto dto) {
        Page<Object> page = PageHelper.startPage(dto.getPage(), dto.getLimit());
        List<ProductVariantVo> list = baseMapper.getProductVariantPage(dto);
        return RPage.ok(list, dto.getPage(), dto.getLimit(), page.getTotal());
    }

    public ProductVariantVo getProductVariantDetails(Integer variantId) {
        return baseMapper.getProductVariantDetails(variantId);
    }

//    public Boolean saveProductVariant(ProductVariantDto dto) {
//        return save(BeanUtil.copyProperties(dto, ProductVariantEntity.class));
//    }
//
//    public Boolean updateProductVariant(ProductVariantDto dto) {
//        return updateById(BeanUtil.copyProperties(dto, ProductVariantEntity.class));
//    }
//
//    public Boolean deleteProductVariant(Integer variantId) {
//        return removeById(variantId);
//    }


    public List<ProductPartVo> getProductPartList() {
        return productService.getProductPartList();
    }

    /**
     * 生成商品SKU组合========================================================================================
     *
     * @param productId 商品ID
     * @return 是否成功
     */
    @Transactional(rollbackFor = Exception.class)
    public Boolean initProductSku(Integer productId) {
        // 删除原有选项
        this.removeByProductId(productId);
        // 查询商品信息
        ProductVo productVo = productService.getProductDetails(productId);
        //商品图片
        List<String> productImageTwo = productVo.getProductImageTwo();

        // 查询商品选项
        List<ProductOptionVo> productOptionList = productOptionService.getProductOptionList(productId);
        // 验证商品选项
        if (CollectionUtil.isEmpty(productOptionList)) {
            log.warn("该商品没有配置选项信息");
            throw new CommonException("该商品没有配置选项信息");
        }
        // 生成所有可能的选项组合
        List<List<String>> allCombinations = generateOptionCombinations(productOptionList);
        // 创建SKU变体列表
        List<ProductVariantEntity> variants = new ArrayList<>();
        for (List<String> combination : allCombinations) {
            // 将组合转换为字符串表示形式
            String combinationStr = combination.stream().collect(Collectors.joining("-"));

            ProductVariantEntity variant = new ProductVariantEntity();
            variant.setProductId(productId);
            variant.setOriginalPrice(productVo.getOriginalPrice());
            variant.setPrice(productVo.getActualPrice());
            variant.setStock(productVo.getStockQuantity());
            variant.setStatus(Boolean.TRUE);
            variant.setOptionCombination(combinationStr);
            //根据实际图片替换
            if(CollectionUtil.isNotEmpty(productImageTwo)){
                variant.setVariantImage(productImageTwo.getFirst());
            }
            variants.add(variant);
        }
        // 保存SKU变体到数据库
        return saveProductVariants(variants);
    }

    public Boolean removeByProductId(Integer productId) {
        LambdaQueryWrapper<ProductVariantEntity> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(ProductVariantEntity::getProductId, productId);
        return remove(queryWrapper);
    }

    /**
     * 生成所有可能的选项组合（笛卡尔积）
     *
     * @param options 商品选项列表
     * @return 所有可能的组合
     */
    private List<List<String>> generateOptionCombinations(List<ProductOptionVo> options) {
        // 如果没有选项，返回空列表
        if (CollectionUtil.isEmpty(options)) {
            return Collections.emptyList();
        }
        // 递归生成组合
        return generateCombinationsRecursive(options, 0, new ArrayList<>());
    }

    /**
     * 递归生成选项组合
     *
     * @param options 所有选项
     * @param index   当前处理的选项索引
     * @param current 当前组合
     * @return 所有可能的组合
     */
    private List<List<String>> generateCombinationsRecursive(List<ProductOptionVo> options,
                                                             int index,
                                                             List<String> current) {
        List<List<String>> result = new ArrayList<>();
        // 递归终止条件：处理完所有选项
        if (index >= options.size()) {
            result.add(new ArrayList<>(current));
            return result;
        }
        // 获取当前选项的值列表
        ProductOptionVo currentOption = options.get(index);
        List<String> values = currentOption.getValueList();
        // 如果当前选项没有值，跳过
        if (CollectionUtil.isEmpty(values)) {
            return generateCombinationsRecursive(options, index + 1, current);
        }
        // 遍历当前选项的所有值
        for (String value : values) {
            // 添加当前值到组合
            current.add(value);
            // 递归处理下一个选项
            result.addAll(generateCombinationsRecursive(options, index + 1, current));
            // 回溯，移除当前值
//            current.remove(current.size() - 1);
            current.removeLast();
        }
        return result;
    }

    /**
     * 保存商品变体到数据库
     *
     * @param variants 变体列表
     * @return 是否成功
     */
    private Boolean saveProductVariants(List<ProductVariantEntity> variants) {
        if (CollectionUtil.isEmpty(variants)) {
            return false;
        }
        try {
            // 批量保存变体到数据库
            return this.saveBatch(variants);
        } catch (Exception e) {
            log.error("保存商品变体失败", e);
            return false;
        }
    }

}




